<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples,
             MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators,
             PolyKinds, NegativeLiterals, DataKinds #-}</span><span>
</span><span id="line-4"></span><span class="hs-comment">-- NegativeLiterals: see Note [Fixity of (-&gt;)]</span><span>
</span><span id="line-5"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-7"></span><span class="hs-comment">-- Module      :  GHC.Types</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Copyright   :  (c) The University of Glasgow 2009</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- License     :  see libraries/ghc-prim/LICENSE</span><span>
</span><span id="line-10"></span><span class="hs-comment">--</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Maintainer  :  cvs-ghc@haskell.org</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Stability   :  internal</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- Portability :  non-portable (GHC Extensions)</span><span>
</span><span id="line-14"></span><span class="hs-comment">--</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- GHC type definitions.</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- Use GHC.Exts from the base package instead of importing this</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- module directly.</span><span>
</span><span id="line-18"></span><span class="hs-comment">--</span><span>
</span><span id="line-19"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-20"></span><span>
</span><span id="line-21"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.Types</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-22"></span><span>        </span><span class="hs-comment">-- Data types that are built-in syntax</span><span>
</span><span id="line-23"></span><span>        </span><span class="hs-comment">-- They are defined here, but not explicitly exported</span><span>
</span><span id="line-24"></span><span>        </span><span class="hs-comment">--</span><span>
</span><span id="line-25"></span><span>        </span><span class="hs-comment">--    Lists:          []( [], (:) )</span><span>
</span><span id="line-26"></span><span>        </span><span class="hs-comment">--    Type equality:  (~)( Eq# )</span><span>
</span><span id="line-27"></span><span>
</span><span id="line-28"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Bool"><span class="hs-identifier">Bool</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Char"><span class="hs-identifier">Char</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Int"><span class="hs-identifier">Int</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Word"><span class="hs-identifier">Word</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-29"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Float"><span class="hs-identifier">Float</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Double"><span class="hs-identifier">Double</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-30"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Ordering"><span class="hs-identifier">Ordering</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#IO"><span class="hs-identifier">IO</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-31"></span><span>        </span><span class="annot"><a href="GHC.Types.html#isTrue%23"><span class="hs-identifier">isTrue#</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-32"></span><span>        </span><span class="annot"><a href="GHC.Types.html#SPEC"><span class="hs-identifier">SPEC</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-33"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Nat"><span class="hs-identifier">Nat</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Symbol"><span class="hs-identifier">Symbol</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-34"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Any"><span class="hs-identifier">Any</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-35"></span><span>        </span><span class="hs-keyword">type</span><span> </span><span class="annot"><a href="GHC.Types.html#~~"><span class="hs-operator">(~~)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Coercible"><span class="hs-identifier">Coercible</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-36"></span><span>        </span><span class="annot"><a href="GHC.Prim.html#TYPE"><span class="hs-identifier">TYPE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#RuntimeRep"><span class="hs-identifier">RuntimeRep</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Type"><span class="hs-identifier">Type</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#Constraint"><span class="hs-identifier">Constraint</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-37"></span><span>          </span><span class="hs-comment">-- The historical type * should ideally be written as</span><span>
</span><span id="line-38"></span><span>          </span><span class="hs-comment">-- `type *`, without the parentheses. But that's a true</span><span>
</span><span id="line-39"></span><span>          </span><span class="hs-comment">-- pain to parse, and for little gain.</span><span>
</span><span id="line-40"></span><span>        </span><span class="annot"><a href="GHC.Types.html#VecCount"><span class="hs-identifier">VecCount</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#VecElem"><span class="hs-identifier">VecElem</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-41"></span><span>
</span><span id="line-42"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Runtime type representation</span></span><span>
</span><span id="line-43"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Module"><span class="hs-identifier">Module</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#TrName"><span class="hs-identifier">TrName</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#TyCon"><span class="hs-identifier">TyCon</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#TypeLitSort"><span class="hs-identifier">TypeLitSort</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-44"></span><span>        </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier">KindRep</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#KindBndr"><span class="hs-identifier">KindBndr</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Multiplicity Types</span></span><span>
</span><span id="line-47"></span><span>        </span><span class="annot"><a href="GHC.Types.html#Multiplicity"><span class="hs-identifier">Multiplicity</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier">MultMul</span></a></span><span>
</span><span id="line-48"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-49"></span><span>
</span><span id="line-50"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Prim.html"><span class="hs-identifier">GHC.Prim</span></a></span><span>
</span><span id="line-51"></span><span>
</span><span id="line-52"></span><span class="hs-keyword">infixr</span><span> </span><span class="hs-number">5</span><span> </span><span class="annot"><a href="GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span>
</span><span id="line-53"></span><span>
</span><span id="line-54"></span><span>
</span><span id="line-55"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Functions
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-60"></span><span>
</span><span id="line-61"></span><span class="hs-keyword">infixr</span><span> </span><span class="hs-number">-1</span><span> </span><span class="annot"><a href="GHC.Types.html#-%3E"><span class="hs-glyph hs-type">-&gt;</span></a></span><span>
</span><span id="line-62"></span><span class="hs-comment">{-
Note [Fixity of (-&gt;)]
~~~~~~~~~~~~~~~~~~~~~
This declaration is important for :info (-&gt;) command (issue #10145)
1) The parser parses -&gt; as if it had lower fixity than 0,
   so we conventionally use -1 (issue #15235).
2) Fixities outside the 0-9 range are exceptionally allowed
   for (-&gt;) (see checkPrecP in RdrHsSyn)
3) The negative fixity -1 must be parsed as a single token,
   hence this module requires NegativeLiterals.
-}</span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span class="hs-comment">-- | The regular function type</span><span>
</span><span id="line-75"></span><span class="hs-keyword">type</span><span> </span><span id="-%3E"><span class="hs-special">(</span><span class="hs-glyph">-&gt;</span><span class="hs-special">)</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="GHC.Prim.html#FUN"><span class="hs-identifier hs-type">FUN</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-type">Many</span></a></span><span>
</span><span id="line-76"></span><span class="hs-comment">-- See Note [Linear Types] in Multiplicity</span><span>
</span><span id="line-77"></span><span>
</span><span id="line-78"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Kinds
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-83"></span><span>
</span><span id="line-84"></span><span class="hs-comment">-- | The kind of constraints, like @Show a@</span><span>
</span><span id="line-85"></span><span class="hs-keyword">data</span><span> </span><span id="Constraint"><span class="annot"><a href="GHC.Types.html#Constraint"><span class="hs-identifier hs-var">Constraint</span></a></span></span><span>
</span><span id="line-86"></span><span>
</span><span id="line-87"></span><span class="hs-comment">-- | The kind of types with lifted values. For example @Int :: Type@.</span><span>
</span><span id="line-88"></span><span class="hs-keyword">type</span><span> </span><span id="Type"><span class="annot"><a href="GHC.Types.html#Type"><span class="hs-identifier hs-var">Type</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="GHC.Prim.html#TYPE"><span class="hs-identifier hs-type">TYPE</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#LiftedRep"><span class="hs-identifier hs-type">LiftedRep</span></a></span><span>
</span><span id="line-89"></span><span>
</span><span id="line-90"></span><span class="hs-keyword">data</span><span> </span><span id="Multiplicity"><span class="annot"><a href="GHC.Types.html#Multiplicity"><span class="hs-identifier hs-var">Multiplicity</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Many"><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-var">Many</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span id="One"><span class="annot"><a href="GHC.Types.html#One"><span class="hs-identifier hs-var">One</span></a></span></span><span>
</span><span id="line-91"></span><span>
</span><span id="line-92"></span><span class="hs-keyword">type</span><span> </span><span class="hs-keyword">family</span><span> </span><span id="MultMul"><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier hs-var">MultMul</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679072867"><span class="annot"><a href="#local-6989586621679072867"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.html#Multiplicity"><span class="hs-identifier hs-type">Multiplicity</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679072866"><span class="annot"><a href="#local-6989586621679072866"><span class="hs-identifier hs-type">b</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.html#Multiplicity"><span class="hs-identifier hs-type">Multiplicity</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Types.html#Multiplicity"><span class="hs-identifier hs-type">Multiplicity</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-93"></span><span>  </span><span id="MultMul"><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier hs-var">MultMul</span></a></span></span><span> </span><span id="local-6989586621679072865"><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#One"><span class="hs-identifier hs-type">One</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679072865"><span class="hs-identifier hs-type">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="#local-6989586621679072865"><span class="hs-identifier hs-type">x</span></a></span><span>
</span><span id="line-94"></span><span>  </span><span id="MultMul"><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier hs-var">MultMul</span></a></span></span><span> </span><span id="local-6989586621679072864"><span class="annot"><a href="#local-6989586621679072864"><span class="hs-identifier hs-type">x</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#One"><span class="hs-identifier hs-type">One</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="#local-6989586621679072864"><span class="hs-identifier hs-type">x</span></a></span><span>
</span><span id="line-95"></span><span>  </span><span id="MultMul"><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier hs-var">MultMul</span></a></span></span><span> </span><span id="local-6989586621679072863"><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-type">Many</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679072863"><span class="hs-identifier hs-type">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-type">Many</span></a></span><span>
</span><span id="line-96"></span><span>  </span><span id="MultMul"><span class="annot"><a href="GHC.Types.html#MultMul"><span class="hs-identifier hs-var">MultMul</span></a></span></span><span> </span><span id="local-6989586621679072862"><span class="annot"><a href="#local-6989586621679072862"><span class="hs-identifier hs-type">x</span></a></span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-type">Many</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">'</span><span class="annot"><a href="GHC.Types.html#Many"><span class="hs-identifier hs-type">Many</span></a></span><span>
</span><span id="line-97"></span><span>
</span><span id="line-98"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Nat and Symbol
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-103"></span><span>
</span><span id="line-104"></span><span class="hs-comment">-- | (Kind) This is the kind of type-level natural numbers.</span><span>
</span><span id="line-105"></span><span class="hs-keyword">data</span><span> </span><span id="Nat"><span class="annot"><a href="GHC.Types.html#Nat"><span class="hs-identifier hs-var">Nat</span></a></span></span><span>
</span><span id="line-106"></span><span>
</span><span id="line-107"></span><span class="hs-comment">-- | (Kind) This is the kind of type-level symbols.</span><span>
</span><span id="line-108"></span><span class="hs-comment">-- Declared here because class IP needs it</span><span>
</span><span id="line-109"></span><span class="hs-keyword">data</span><span> </span><span id="Symbol"><span class="annot"><a href="GHC.Types.html#Symbol"><span class="hs-identifier hs-var">Symbol</span></a></span></span><span>
</span><span id="line-110"></span><span>
</span><span id="line-111"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Any
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span class="hs-comment">-- | The type constructor 'Any' is type to which you can unsafely coerce any</span><span>
</span><span id="line-118"></span><span class="hs-comment">-- lifted type, and back. More concretely, for a lifted type @t@ and</span><span>
</span><span id="line-119"></span><span class="hs-comment">-- value @x :: t@, -- @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent</span><span>
</span><span id="line-120"></span><span class="hs-comment">-- to @x@.</span><span>
</span><span id="line-121"></span><span class="hs-comment">--</span><span>
</span><span id="line-122"></span><span class="hs-keyword">type</span><span> </span><span class="hs-keyword">family</span><span> </span><span id="Any"><span class="annot"><a href="GHC.Types.html#Any"><span class="hs-identifier hs-var">Any</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span id="local-6989586621679072861"><span class="annot"><a href="#local-6989586621679072861"><span class="hs-identifier hs-type hs-type">k</span></a></span></span><span> </span><span class="hs-keyword">where</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-123"></span><span class="hs-comment">-- See Note [Any types] in GHC.Builtin.Types. Also, for a bit of history on Any see</span><span>
</span><span id="line-124"></span><span class="hs-comment">-- #10886. Note that this must be a *closed* type family: we need to ensure</span><span>
</span><span id="line-125"></span><span class="hs-comment">-- that this can't reduce to a `data` type for the results discussed in</span><span>
</span><span id="line-126"></span><span class="hs-comment">-- Note [Any types].</span><span>
</span><span id="line-127"></span><span>
</span><span id="line-128"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Lists

   NB: lists are built-in syntax, and hence not explicitly exported
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-135"></span><span>
</span><span id="line-136"></span><span class="hs-comment">-- | The builtin list type, usually written in its non-prefix form @[a]@.</span><span>
</span><span id="line-137"></span><span class="hs-comment">--</span><span>
</span><span id="line-138"></span><span class="hs-comment">-- ==== __Examples__</span><span>
</span><span id="line-139"></span><span class="hs-comment">--</span><span>
</span><span id="line-140"></span><span class="hs-comment">-- Unless the OverloadedLists extension is enabled, list literals are</span><span>
</span><span id="line-141"></span><span class="hs-comment">-- syntatic sugar for repeated applications of @:@ and @[]@.</span><span>
</span><span id="line-142"></span><span class="hs-comment">--</span><span>
</span><span id="line-143"></span><span class="hs-comment">-- &gt;&gt;&gt; 1:2:3:4:[] == [1,2,3,4]</span><span>
</span><span id="line-144"></span><span class="hs-comment">-- True</span><span>
</span><span id="line-145"></span><span class="hs-comment">--</span><span>
</span><span id="line-146"></span><span class="hs-comment">-- Similarly, unless the OverloadedStrings extension is enabled, string</span><span>
</span><span id="line-147"></span><span class="hs-comment">-- literals are syntactic sugar for a lists of characters.</span><span>
</span><span id="line-148"></span><span class="hs-comment">--</span><span>
</span><span id="line-149"></span><span class="hs-comment">-- &gt;&gt;&gt; ['h','e','l','l','o'] == &quot;hello&quot;</span><span>
</span><span id="line-150"></span><span class="hs-comment">-- True</span><span>
</span><span id="line-151"></span><span class="hs-comment">--</span><span>
</span><span id="line-152"></span><span class="hs-keyword">data</span><span> </span><span id="%5B%5D"><span class="hs-special">[</span><span class="hs-special">]</span></span><span> </span><span id="local-6989586621679072860"><span class="annot"><a href="#local-6989586621679072860"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="%5B%5D"><span class="hs-special">[</span><span class="hs-special">]</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="#local-6989586621679072860"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span id="%3A"><span class="annot"><a href="GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679072860"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-153"></span><span>
</span><span id="line-154"></span><span>
</span><span id="line-155"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Ordering
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-160"></span><span>
</span><span id="line-161"></span><span class="hs-keyword">data</span><span> </span><span id="Ordering"><span class="annot"><a href="GHC.Types.html#Ordering"><span class="hs-identifier hs-var">Ordering</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="LT"><span class="annot"><a href="GHC.Types.html#LT"><span class="hs-identifier hs-var">LT</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span id="EQ"><span class="annot"><a href="GHC.Types.html#EQ"><span class="hs-identifier hs-var">EQ</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span id="GT"><span class="annot"><a href="GHC.Types.html#GT"><span class="hs-identifier hs-var">GT</span></a></span></span><span>
</span><span id="line-162"></span><span>
</span><span id="line-163"></span><span>
</span><span id="line-164"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                  Int, Char, Word, Float, Double
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-169"></span><span>
</span><span id="line-170"></span><span class="hs-comment">{- | The character type 'Char' is an enumeration whose values represent
Unicode (or equivalently ISO\/IEC 10646) code points (i.e. characters, see
&lt;http://www.unicode.org/&gt; for details).  This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters).  A character literal in
Haskell has type 'Char'.

To convert a 'Char' to or from the corresponding 'Int' value defined
by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the
'Prelude.Enum' class respectively (or equivalently 'Data.Char.ord' and
'Data.Char.chr').
-}</span><span>
</span><span id="line-182"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsChar&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Char"><span class="annot"><a href="GHC.Types.html#Char"><span class="hs-identifier hs-var">Char</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="C%23"><span class="annot"><a href="GHC.Types.html#C%23"><span class="hs-identifier hs-var">C#</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Char%23"><span class="hs-identifier hs-type">Char#</span></a></span><span>
</span><span id="line-183"></span><span>
</span><span id="line-184"></span><span class="hs-comment">-- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.</span><span>
</span><span id="line-185"></span><span class="hs-comment">-- The exact range for a given implementation can be determined by using</span><span>
</span><span id="line-186"></span><span class="hs-comment">-- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.</span><span>
</span><span id="line-187"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsInt&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Int"><span class="annot"><a href="GHC.Types.html#Int"><span class="hs-identifier hs-var">Int</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="I%23"><span class="annot"><a href="GHC.Types.html#I%23"><span class="hs-identifier hs-var">I#</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Int%23"><span class="hs-identifier hs-type">Int#</span></a></span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span class="hs-comment">-- |A 'Word' is an unsigned integral type, with the same size as 'Int'.</span><span>
</span><span id="line-190"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsWord&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Word"><span class="annot"><a href="GHC.Types.html#Word"><span class="hs-identifier hs-var">Word</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="W%23"><span class="annot"><a href="GHC.Types.html#W%23"><span class="hs-identifier hs-var">W#</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Word%23"><span class="hs-identifier hs-type">Word#</span></a></span><span>
</span><span id="line-191"></span><span>
</span><span id="line-192"></span><span class="hs-comment">-- | Single-precision floating point numbers.</span><span>
</span><span id="line-193"></span><span class="hs-comment">-- It is desirable that this type be at least equal in range and precision</span><span>
</span><span id="line-194"></span><span class="hs-comment">-- to the IEEE single-precision type.</span><span>
</span><span id="line-195"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsFloat&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Float"><span class="annot"><a href="GHC.Types.html#Float"><span class="hs-identifier hs-var">Float</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="F%23"><span class="annot"><a href="GHC.Types.html#F%23"><span class="hs-identifier hs-var">F#</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Float%23"><span class="hs-identifier hs-type">Float#</span></a></span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span class="hs-comment">-- | Double-precision floating point numbers.</span><span>
</span><span id="line-198"></span><span class="hs-comment">-- It is desirable that this type be at least equal in range and precision</span><span>
</span><span id="line-199"></span><span class="hs-comment">-- to the IEEE double-precision type.</span><span>
</span><span id="line-200"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsDouble&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Double"><span class="annot"><a href="GHC.Types.html#Double"><span class="hs-identifier hs-var">Double</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="D%23"><span class="annot"><a href="GHC.Types.html#D%23"><span class="hs-identifier hs-var">D#</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Double%23"><span class="hs-identifier hs-type">Double#</span></a></span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>
</span><span id="line-203"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                    IO
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-208"></span><span>
</span><span id="line-209"></span><span class="hs-comment">{- |
A value of type @'IO' a@ is a computation which, when performed,
does some I\/O before returning a value of type @a@.

There is really only one way to \&quot;perform\&quot; an I\/O action: bind it to
@Main.main@ in your program.  When your program is run, the I\/O will
be performed.  It isn't possible to perform I\/O from an arbitrary
function, unless that function is itself in the 'IO' monad and called
at some point, directly or indirectly, from @Main.main@.

'IO' is a monad, so 'IO' actions can be combined using either the do-notation
or the 'Prelude.&gt;&gt;' and 'Prelude.&gt;&gt;=' operations from the 'Prelude.Monad'
class.
-}</span><span>
</span><span id="line-223"></span><span class="hs-keyword">newtype</span><span> </span><span id="IO"><span class="annot"><a href="GHC.Types.html#IO"><span class="hs-identifier hs-var">IO</span></a></span></span><span> </span><span id="local-6989586621679072859"><span class="annot"><a href="#local-6989586621679072859"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="IO"><span class="annot"><a href="GHC.Types.html#IO"><span class="hs-identifier hs-var">IO</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Prim.html#State%23"><span class="hs-identifier hs-type">State#</span></a></span><span> </span><span class="annot"><a href="GHC.Prim.html#RealWorld"><span class="hs-identifier hs-type">RealWorld</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(#</span><span> </span><span class="annot"><a href="GHC.Prim.html#State%23"><span class="hs-identifier hs-type">State#</span></a></span><span> </span><span class="annot"><a href="GHC.Prim.html#RealWorld"><span class="hs-identifier hs-type">RealWorld</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679072859"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">#)</span><span class="hs-special">)</span><span>
</span><span id="line-224"></span><span>
</span><span id="line-225"></span><span>
</span><span id="line-226"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                    (~) and Coercible

   NB: (~) is built-in syntax, and hence not explicitly exported
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-233"></span><span>
</span><span id="line-234"></span><span class="hs-comment">{-
Note [Kind-changing of (~) and Coercible]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

(~) and Coercible are tricky to define. To the user, they must appear as
constraints, but we cannot define them as such in Haskell. But we also cannot
just define them only in GHC.Prim (like (-&gt;)), because we need a real module
for them, e.g. to compile the constructor's info table.

Furthermore the type of MkCoercible cannot be written in Haskell
(no syntax for ~#R).

So we define them as regular data types in GHC.Types, and do magic in GHC.Builtin.Types,
inside GHC, to change the kind and type.
-}</span><span>
</span><span id="line-249"></span><span>
</span><span id="line-250"></span><span>
</span><span id="line-251"></span><span class="hs-comment">-- | Lifted, heterogeneous equality. By lifted, we mean that it</span><span>
</span><span id="line-252"></span><span class="hs-comment">-- can be bogus (deferred type error). By heterogeneous, the two</span><span>
</span><span id="line-253"></span><span class="hs-comment">-- types @a@ and @b@ might have different kinds. Because @~~@ can</span><span>
</span><span id="line-254"></span><span class="hs-comment">-- appear unexpectedly in error messages to users who do not care</span><span>
</span><span id="line-255"></span><span class="hs-comment">-- about the difference between heterogeneous equality @~~@ and</span><span>
</span><span id="line-256"></span><span class="hs-comment">-- homogeneous equality @~@, this is printed as @~@ unless</span><span>
</span><span id="line-257"></span><span class="hs-comment">-- @-fprint-equality-relations@ is set.</span><span>
</span><span id="line-258"></span><span class="hs-comment">--</span><span>
</span><span id="line-259"></span><span class="hs-comment">-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~~:'.</span><span>
</span><span id="line-260"></span><span class="hs-keyword">class</span><span> </span><span id="local-6989586621679072858"><span class="annot"><a href="#local-6989586621679072858"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span id="~~"><span class="annot"><a href="GHC.Types.html#~~"><span class="hs-operator hs-var">~~</span></a></span></span><span> </span><span id="local-6989586621679072857"><span class="annot"><a href="#local-6989586621679072857"><span class="hs-identifier hs-type">b</span></a></span></span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span>  </span><span class="hs-comment">-- See also Note [The equality types story] in GHC.Builtin.Types.Prim</span><span>
</span><span id="line-263"></span><span>
</span><span id="line-264"></span><span class="hs-comment">-- | Lifted, homogeneous equality. By lifted, we mean that it</span><span>
</span><span id="line-265"></span><span class="hs-comment">-- can be bogus (deferred type error). By homogeneous, the two</span><span>
</span><span id="line-266"></span><span class="hs-comment">-- types @a@ and @b@ must have the same kinds.</span><span>
</span><span id="line-267"></span><span>
</span><span id="line-268"></span><span class="hs-comment">-- In @0.7.0@, the fixity was set to @infix 4@ to match the fixity of 'Data.Type.Equality.:~:'.</span><span>
</span><span id="line-269"></span><span class="hs-keyword">class</span><span> </span><span id="local-6989586621679072856"><span class="annot"><a href="#local-6989586621679072856"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span id="~"><span class="annot"><a href="GHC.Types.html#~"><span class="hs-operator hs-var">~</span></a></span></span><span> </span><span id="local-6989586621679072855"><span class="annot"><a href="#local-6989586621679072855"><span class="hs-identifier hs-type">b</span></a></span></span><span>
</span><span id="line-270"></span><span>
</span><span id="line-271"></span><span class="hs-keyword">infix</span><span> </span><span class="hs-number">4</span><span> </span><span class="annot"><a href="GHC.Types.html#~"><span class="hs-operator hs-type">~</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Types.html#~~"><span class="hs-operator hs-type">~~</span></a></span><span>
</span><span id="line-272"></span><span>  </span><span class="hs-comment">-- See also Note [The equality types story] in GHC.Builtin.Types.Prim</span><span>
</span><span id="line-273"></span><span>
</span><span id="line-274"></span><span class="hs-comment">-- | @Coercible@ is a two-parameter class that has instances for types @a@ and @b@ if</span><span>
</span><span id="line-275"></span><span class="hs-comment">--      the compiler can infer that they have the same representation. This class</span><span>
</span><span id="line-276"></span><span class="hs-comment">--      does not have regular instances; instead they are created on-the-fly during</span><span>
</span><span id="line-277"></span><span class="hs-comment">--      type-checking. Trying to manually declare an instance of @Coercible@</span><span>
</span><span id="line-278"></span><span class="hs-comment">--      is an error.</span><span>
</span><span id="line-279"></span><span class="hs-comment">--</span><span>
</span><span id="line-280"></span><span class="hs-comment">--      Nevertheless one can pretend that the following three kinds of instances</span><span>
</span><span id="line-281"></span><span class="hs-comment">--      exist. First, as a trivial base-case:</span><span>
</span><span id="line-282"></span><span class="hs-comment">--</span><span>
</span><span id="line-283"></span><span class="hs-comment">--      @instance Coercible a a@</span><span>
</span><span id="line-284"></span><span class="hs-comment">--</span><span>
</span><span id="line-285"></span><span class="hs-comment">--      Furthermore, for every type constructor there is</span><span>
</span><span id="line-286"></span><span class="hs-comment">--      an instance that allows to coerce under the type constructor. For</span><span>
</span><span id="line-287"></span><span class="hs-comment">--      example, let @D@ be a prototypical type constructor (@data@ or</span><span>
</span><span id="line-288"></span><span class="hs-comment">--      @newtype@) with three type arguments, which have roles @nominal@,</span><span>
</span><span id="line-289"></span><span class="hs-comment">--      @representational@ resp. @phantom@. Then there is an instance of</span><span>
</span><span id="line-290"></span><span class="hs-comment">--      the form</span><span>
</span><span id="line-291"></span><span class="hs-comment">--</span><span>
</span><span id="line-292"></span><span class="hs-comment">--      @instance Coercible b b\' =&gt; Coercible (D a b c) (D a b\' c\')@</span><span>
</span><span id="line-293"></span><span class="hs-comment">--</span><span>
</span><span id="line-294"></span><span class="hs-comment">--      Note that the @nominal@ type arguments are equal, the</span><span>
</span><span id="line-295"></span><span class="hs-comment">--      @representational@ type arguments can differ, but need to have a</span><span>
</span><span id="line-296"></span><span class="hs-comment">--      @Coercible@ instance themself, and the @phantom@ type arguments can be</span><span>
</span><span id="line-297"></span><span class="hs-comment">--      changed arbitrarily.</span><span>
</span><span id="line-298"></span><span class="hs-comment">--</span><span>
</span><span id="line-299"></span><span class="hs-comment">--      The third kind of instance exists for every @newtype NT = MkNT T@ and</span><span>
</span><span id="line-300"></span><span class="hs-comment">--      comes in two variants, namely</span><span>
</span><span id="line-301"></span><span class="hs-comment">--</span><span>
</span><span id="line-302"></span><span class="hs-comment">--      @instance Coercible a T =&gt; Coercible a NT@</span><span>
</span><span id="line-303"></span><span class="hs-comment">--</span><span>
</span><span id="line-304"></span><span class="hs-comment">--      @instance Coercible T b =&gt; Coercible NT b@</span><span>
</span><span id="line-305"></span><span class="hs-comment">--</span><span>
</span><span id="line-306"></span><span class="hs-comment">--      This instance is only usable if the constructor @MkNT@ is in scope.</span><span>
</span><span id="line-307"></span><span class="hs-comment">--</span><span>
</span><span id="line-308"></span><span class="hs-comment">--      If, as a library author of a type constructor like @Set a@, you</span><span>
</span><span id="line-309"></span><span class="hs-comment">--      want to prevent a user of your module to write</span><span>
</span><span id="line-310"></span><span class="hs-comment">--      @coerce :: Set T -&gt; Set NT@,</span><span>
</span><span id="line-311"></span><span class="hs-comment">--      you need to set the role of @Set@\'s type parameter to @nominal@,</span><span>
</span><span id="line-312"></span><span class="hs-comment">--      by writing</span><span>
</span><span id="line-313"></span><span class="hs-comment">--</span><span>
</span><span id="line-314"></span><span class="hs-comment">--      @type role Set nominal@</span><span>
</span><span id="line-315"></span><span class="hs-comment">--</span><span>
</span><span id="line-316"></span><span class="hs-comment">--      For more details about this feature, please refer to</span><span>
</span><span id="line-317"></span><span class="hs-comment">--      &lt;http://research.microsoft.com/en-us/um/people/simonpj/papers/ext-f/coercible.pdf Safe Coercions&gt;</span><span>
</span><span id="line-318"></span><span class="hs-comment">--      by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.</span><span>
</span><span id="line-319"></span><span class="hs-comment">--</span><span>
</span><span id="line-320"></span><span class="hs-comment">--      @since 4.7.0.0</span><span>
</span><span id="line-321"></span><span class="hs-keyword">class</span><span> </span><span id="Coercible"><span class="annot"><a href="GHC.Types.html#Coercible"><span class="hs-identifier hs-var">Coercible</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679072854"><span id="local-6989586621679072853"><span class="annot"><a href="#local-6989586621679072853"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679072854"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679072852"><span class="annot"><a href="#local-6989586621679072852"><span class="hs-identifier hs-type">b</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679072854"><span class="hs-identifier hs-type">k</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-322"></span><span>  </span><span class="hs-comment">-- See also Note [The equality types story] in GHC.Builtin.Types.Prim</span><span>
</span><span id="line-323"></span><span>
</span><span id="line-324"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                   Bool, and isTrue#
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-329"></span><span>
</span><span id="line-330"></span><span class="hs-keyword">data</span><span> </span><span class="hs-pragma">{-# CTYPE</span><span> </span><span class="hs-pragma">&quot;HsBool&quot;</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span id="Bool"><span class="annot"><a href="GHC.Types.html#Bool"><span class="hs-identifier hs-var">Bool</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="False"><span class="annot"><a href="GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span id="True"><span class="annot"><a href="GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span></span><span>
</span><span id="line-331"></span><span>
</span><span id="line-332"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="GHC.Types.html#isTrue%23"><span class="hs-pragma hs-type">isTrue#</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-333"></span><span class="hs-comment">-- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False</span><span>
</span><span id="line-334"></span><span class="hs-comment">--   if it is 0#.</span><span>
</span><span id="line-335"></span><span class="annot"><a href="GHC.Types.html#isTrue%23"><span class="hs-identifier hs-type">isTrue#</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Prim.html#Int%23"><span class="hs-identifier hs-type">Int#</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span>   </span><span class="hs-comment">-- See Note [Optimizing isTrue#]</span><span>
</span><span id="line-336"></span><span id="isTrue%23"><span class="annot"><span class="annottext">isTrue# :: Int# -&gt; Bool
</span><a href="GHC.Types.html#isTrue%23"><span class="hs-identifier hs-var hs-var">isTrue#</span></a></span></span><span> </span><span id="local-6989586621679072851"><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679072851"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int# -&gt; Bool
forall a. Int# -&gt; a
</span><a href="GHC.Prim.html#tagToEnum%23"><span class="hs-identifier hs-var">tagToEnum#</span></a></span><span> </span><span class="annot"><span class="annottext">Int#
</span><a href="#local-6989586621679072851"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-337"></span><span>
</span><span id="line-338"></span><span class="hs-comment">{- Note [Optimizing isTrue#]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Current definition of isTrue# is a temporary workaround. We would like to
have functions isTrue# and isFalse# defined like this:

    isTrue# :: Int# -&gt; Bool
    isTrue# 1# = True
    isTrue# _  = False

    isFalse# :: Int# -&gt; Bool
    isFalse# 0# = True
    isFalse# _  = False

These functions would allow us to safely check if a tag can represent True
or False. Using isTrue# and isFalse# as defined above will not introduce
additional case into the code. When we scrutinize return value of isTrue#
or isFalse#, either explicitly in a case expression or implicitly in a guard,
the result will always be a single case expression (given that optimizations
are turned on). This results from case-of-case transformation. Consider this
code (this is both valid Haskell and Core):

case isTrue# (a &gt;# b) of
    True  -&gt; e1
    False -&gt; e2

Inlining isTrue# gives:

case (case (a &gt;# b) of { 1# -&gt; True; _ -&gt; False } ) of
    True  -&gt; e1
    False -&gt; e2

Case-of-case transforms that to:

case (a &gt;# b) of
  1# -&gt; case True of
          True  -&gt; e1
          False -&gt; e2
  _  -&gt; case False of
          True  -&gt; e1
          False -&gt; e2

Which is then simplified by case-of-known-constructor:

case (a &gt;# b) of
  1# -&gt; e1
  _  -&gt; e2

While we get good Core here, the code generator will generate very bad Cmm
if e1 or e2 do allocation. It will push heap checks into case alternatives
which results in about 2.5% increase in code size. Until this is improved we
just make isTrue# an alias to tagToEnum#. This is a temporary solution (if
you're reading this in 2023 then things went wrong). See #8326.
-}</span><span>
</span><span id="line-391"></span><span>
</span><span id="line-392"></span><span>
</span><span id="line-393"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                    SPEC
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-398"></span><span>
</span><span id="line-399"></span><span class="hs-comment">-- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform</span><span>
</span><span id="line-400"></span><span class="hs-comment">-- the compiler when to be particularly aggressive. In particular, it</span><span>
</span><span id="line-401"></span><span class="hs-comment">-- tells GHC to specialize regardless of size or the number of</span><span>
</span><span id="line-402"></span><span class="hs-comment">-- specializations. However, not all loops fall into this category.</span><span>
</span><span id="line-403"></span><span class="hs-comment">--</span><span>
</span><span id="line-404"></span><span class="hs-comment">-- Libraries can specify this by using 'SPEC' data type to inform which</span><span>
</span><span id="line-405"></span><span class="hs-comment">-- loops should be aggressively specialized.</span><span>
</span><span id="line-406"></span><span class="hs-keyword">data</span><span> </span><span id="SPEC"><span class="annot"><a href="GHC.Types.html#SPEC"><span class="hs-identifier hs-var">SPEC</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="SPEC"><span class="annot"><a href="GHC.Types.html#SPEC"><span class="hs-identifier hs-var">SPEC</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span id="SPEC2"><span class="annot"><a href="GHC.Types.html#SPEC2"><span class="hs-identifier hs-var">SPEC2</span></a></span></span><span>
</span><span id="line-407"></span><span>
</span><span id="line-408"></span><span>
</span><span id="line-409"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
                    Levity polymorphism
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-414"></span><span>
</span><span id="line-415"></span><span>
</span><span id="line-416"></span><span class="hs-comment">-- | GHC maintains a property that the kind of all inhabited types</span><span>
</span><span id="line-417"></span><span class="hs-comment">-- (as distinct from type constructors or type-level data) tells us</span><span>
</span><span id="line-418"></span><span class="hs-comment">-- the runtime representation of values of that type. This datatype</span><span>
</span><span id="line-419"></span><span class="hs-comment">-- encodes the choice of runtime value.</span><span>
</span><span id="line-420"></span><span class="hs-comment">-- Note that 'TYPE' is parameterised by 'RuntimeRep'; this is precisely</span><span>
</span><span id="line-421"></span><span class="hs-comment">-- what we mean by the fact that a type's kind encodes the runtime</span><span>
</span><span id="line-422"></span><span class="hs-comment">-- representation.</span><span>
</span><span id="line-423"></span><span class="hs-comment">--</span><span>
</span><span id="line-424"></span><span class="hs-comment">-- For boxed values (that is, values that are represented by a pointer),</span><span>
</span><span id="line-425"></span><span class="hs-comment">-- a further distinction is made, between lifted types (that contain &#8869;),</span><span>
</span><span id="line-426"></span><span class="hs-comment">-- and unlifted ones (that don't).</span><span>
</span><span id="line-427"></span><span class="hs-keyword">data</span><span> </span><span id="RuntimeRep"><span class="annot"><a href="GHC.Types.html#RuntimeRep"><span class="hs-identifier hs-var">RuntimeRep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="VecRep"><span class="annot"><a href="GHC.Types.html#VecRep"><span class="hs-identifier hs-var">VecRep</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#VecCount"><span class="hs-identifier hs-type">VecCount</span></a></span><span> </span><span class="annot"><a href="GHC.Types.html#VecElem"><span class="hs-identifier hs-type">VecElem</span></a></span><span>   </span><span class="hs-comment">-- ^ a SIMD vector type</span><span>
</span><span id="line-428"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="TupleRep"><span class="annot"><a href="GHC.Types.html#TupleRep"><span class="hs-identifier hs-var">TupleRep</span></a></span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Types.html#RuntimeRep"><span class="hs-identifier hs-type">RuntimeRep</span></a></span><span class="hs-special">]</span><span>     </span><span class="hs-comment">-- ^ An unboxed tuple of the given reps</span><span>
</span><span id="line-429"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="SumRep"><span class="annot"><a href="GHC.Types.html#SumRep"><span class="hs-identifier hs-var">SumRep</span></a></span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Types.html#RuntimeRep"><span class="hs-identifier hs-type">RuntimeRep</span></a></span><span class="hs-special">]</span><span>       </span><span class="hs-comment">-- ^ An unboxed sum of the given reps</span><span>
</span><span id="line-430"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="LiftedRep"><span class="annot"><a href="GHC.Types.html#LiftedRep"><span class="hs-identifier hs-var">LiftedRep</span></a></span></span><span>       </span><span class="hs-comment">-- ^ lifted; represented by a pointer</span><span>
</span><span id="line-431"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="UnliftedRep"><span class="annot"><a href="GHC.Types.html#UnliftedRep"><span class="hs-identifier hs-var">UnliftedRep</span></a></span></span><span>     </span><span class="hs-comment">-- ^ unlifted; represented by a pointer</span><span>
</span><span id="line-432"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="IntRep"><span class="annot"><a href="GHC.Types.html#IntRep"><span class="hs-identifier hs-var">IntRep</span></a></span></span><span>          </span><span class="hs-comment">-- ^ signed, word-sized value</span><span>
</span><span id="line-433"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Int8Rep"><span class="annot"><a href="GHC.Types.html#Int8Rep"><span class="hs-identifier hs-var">Int8Rep</span></a></span></span><span>         </span><span class="hs-comment">-- ^ signed,  8-bit value</span><span>
</span><span id="line-434"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Int16Rep"><span class="annot"><a href="GHC.Types.html#Int16Rep"><span class="hs-identifier hs-var">Int16Rep</span></a></span></span><span>        </span><span class="hs-comment">-- ^ signed, 16-bit value</span><span>
</span><span id="line-435"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Int32Rep"><span class="annot"><a href="GHC.Types.html#Int32Rep"><span class="hs-identifier hs-var">Int32Rep</span></a></span></span><span>        </span><span class="hs-comment">-- ^ signed, 32-bit value</span><span>
</span><span id="line-436"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Int64Rep"><span class="annot"><a href="GHC.Types.html#Int64Rep"><span class="hs-identifier hs-var">Int64Rep</span></a></span></span><span>        </span><span class="hs-comment">-- ^ signed, 64-bit value (on 32-bit only)</span><span>
</span><span id="line-437"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="WordRep"><span class="annot"><a href="GHC.Types.html#WordRep"><span class="hs-identifier hs-var">WordRep</span></a></span></span><span>         </span><span class="hs-comment">-- ^ unsigned, word-sized value</span><span>
</span><span id="line-438"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Word8Rep"><span class="annot"><a href="GHC.Types.html#Word8Rep"><span class="hs-identifier hs-var">Word8Rep</span></a></span></span><span>        </span><span class="hs-comment">-- ^ unsigned,  8-bit value</span><span>
</span><span id="line-439"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Word16Rep"><span class="annot"><a href="GHC.Types.html#Word16Rep"><span class="hs-identifier hs-var">Word16Rep</span></a></span></span><span>       </span><span class="hs-comment">-- ^ unsigned, 16-bit value</span><span>
</span><span id="line-440"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Word32Rep"><span class="annot"><a href="GHC.Types.html#Word32Rep"><span class="hs-identifier hs-var">Word32Rep</span></a></span></span><span>       </span><span class="hs-comment">-- ^ unsigned, 32-bit value</span><span>
</span><span id="line-441"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="Word64Rep"><span class="annot"><a href="GHC.Types.html#Word64Rep"><span class="hs-identifier hs-var">Word64Rep</span></a></span></span><span>       </span><span class="hs-comment">-- ^ unsigned, 64-bit value (on 32-bit only)</span><span>
</span><span id="line-442"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="AddrRep"><span class="annot"><a href="GHC.Types.html#AddrRep"><span class="hs-identifier hs-var">AddrRep</span></a></span></span><span>         </span><span class="hs-comment">-- ^ A pointer, but /not/ to a Haskell value</span><span>
</span><span id="line-443"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="FloatRep"><span class="annot"><a href="GHC.Types.html#FloatRep"><span class="hs-identifier hs-var">FloatRep</span></a></span></span><span>        </span><span class="hs-comment">-- ^ a 32-bit floating point number</span><span>
</span><span id="line-444"></span><span>                </span><span class="hs-glyph">|</span><span> </span><span id="DoubleRep"><span class="annot"><a href="GHC.Types.html#DoubleRep"><span class="hs-identifier hs-var">DoubleRep</span></a></span></span><span>       </span><span class="hs-comment">-- ^ a 64-bit floating point number</span><span>
</span><span id="line-445"></span><span>
</span><span id="line-446"></span><span class="hs-comment">-- RuntimeRep is intimately tied to TyCon.RuntimeRep (in GHC proper). See</span><span>
</span><span id="line-447"></span><span class="hs-comment">-- Note [RuntimeRep and PrimRep] in RepType.</span><span>
</span><span id="line-448"></span><span class="hs-comment">-- See also Note [Wiring in RuntimeRep] in GHC.Builtin.Types</span><span>
</span><span id="line-449"></span><span>
</span><span id="line-450"></span><span class="hs-comment">-- | Length of a SIMD vector type</span><span>
</span><span id="line-451"></span><span class="hs-keyword">data</span><span> </span><span id="VecCount"><span class="annot"><a href="GHC.Types.html#VecCount"><span class="hs-identifier hs-var">VecCount</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Vec2"><span class="annot"><a href="GHC.Types.html#Vec2"><span class="hs-identifier hs-var">Vec2</span></a></span></span><span>
</span><span id="line-452"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Vec4"><span class="annot"><a href="GHC.Types.html#Vec4"><span class="hs-identifier hs-var">Vec4</span></a></span></span><span>
</span><span id="line-453"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Vec8"><span class="annot"><a href="GHC.Types.html#Vec8"><span class="hs-identifier hs-var">Vec8</span></a></span></span><span>
</span><span id="line-454"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Vec16"><span class="annot"><a href="GHC.Types.html#Vec16"><span class="hs-identifier hs-var">Vec16</span></a></span></span><span>
</span><span id="line-455"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Vec32"><span class="annot"><a href="GHC.Types.html#Vec32"><span class="hs-identifier hs-var">Vec32</span></a></span></span><span>
</span><span id="line-456"></span><span>              </span><span class="hs-glyph">|</span><span> </span><span id="Vec64"><span class="annot"><a href="GHC.Types.html#Vec64"><span class="hs-identifier hs-var">Vec64</span></a></span></span><span>
</span><span id="line-457"></span><span class="hs-comment">-- Enum, Bounded instances in GHC.Enum</span><span>
</span><span id="line-458"></span><span>
</span><span id="line-459"></span><span class="hs-comment">-- | Element of a SIMD vector type</span><span>
</span><span id="line-460"></span><span class="hs-keyword">data</span><span> </span><span id="VecElem"><span class="annot"><a href="GHC.Types.html#VecElem"><span class="hs-identifier hs-var">VecElem</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Int8ElemRep"><span class="annot"><a href="GHC.Types.html#Int8ElemRep"><span class="hs-identifier hs-var">Int8ElemRep</span></a></span></span><span>
</span><span id="line-461"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Int16ElemRep"><span class="annot"><a href="GHC.Types.html#Int16ElemRep"><span class="hs-identifier hs-var">Int16ElemRep</span></a></span></span><span>
</span><span id="line-462"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Int32ElemRep"><span class="annot"><a href="GHC.Types.html#Int32ElemRep"><span class="hs-identifier hs-var">Int32ElemRep</span></a></span></span><span>
</span><span id="line-463"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Int64ElemRep"><span class="annot"><a href="GHC.Types.html#Int64ElemRep"><span class="hs-identifier hs-var">Int64ElemRep</span></a></span></span><span>
</span><span id="line-464"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Word8ElemRep"><span class="annot"><a href="GHC.Types.html#Word8ElemRep"><span class="hs-identifier hs-var">Word8ElemRep</span></a></span></span><span>
</span><span id="line-465"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Word16ElemRep"><span class="annot"><a href="GHC.Types.html#Word16ElemRep"><span class="hs-identifier hs-var">Word16ElemRep</span></a></span></span><span>
</span><span id="line-466"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Word32ElemRep"><span class="annot"><a href="GHC.Types.html#Word32ElemRep"><span class="hs-identifier hs-var">Word32ElemRep</span></a></span></span><span>
</span><span id="line-467"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="Word64ElemRep"><span class="annot"><a href="GHC.Types.html#Word64ElemRep"><span class="hs-identifier hs-var">Word64ElemRep</span></a></span></span><span>
</span><span id="line-468"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="FloatElemRep"><span class="annot"><a href="GHC.Types.html#FloatElemRep"><span class="hs-identifier hs-var">FloatElemRep</span></a></span></span><span>
</span><span id="line-469"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="DoubleElemRep"><span class="annot"><a href="GHC.Types.html#DoubleElemRep"><span class="hs-identifier hs-var">DoubleElemRep</span></a></span></span><span>
</span><span id="line-470"></span><span class="hs-comment">-- Enum, Bounded instances in GHC.Enum</span><span>
</span><span id="line-471"></span><span>
</span><span id="line-472"></span><span class="hs-comment">{- *********************************************************************
*                                                                      *
             Runtime representation of TyCon
*                                                                      *
********************************************************************* -}</span><span>
</span><span id="line-477"></span><span>
</span><span id="line-478"></span><span class="hs-comment">{- Note [Runtime representation of modules and tycons]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We generate a binding for M.$modName and M.$tcT for every module M and
data type T.  Things to think about

  - We want them to be economical on space; ideally pure data with no thunks.

  - We do this for every module (except this module GHC.Types), so we can't
    depend on anything else (eg string unpacking code)

That's why we have these terribly low-level representations.  The TrName
type lets us use the TrNameS constructor when allocating static data;
but we also need TrNameD for the case where we are deserialising a TyCon
or Module (for example when deserialising a TypeRep), in which case we
can't conveniently come up with an Addr#.
-}</span><span class="hs-cpp">

#include &quot;MachDeps.h&quot;
</span><span>
</span><span id="line-497"></span><span class="hs-keyword">data</span><span> </span><span id="Module"><span class="annot"><a href="GHC.Types.html#Module"><span class="hs-identifier hs-var">Module</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="Module"><span class="annot"><a href="GHC.Types.html#Module"><span class="hs-identifier hs-var">Module</span></a></span></span><span>
</span><span id="line-498"></span><span>                </span><span class="annot"><a href="GHC.Types.html#TrName"><span class="hs-identifier hs-type">TrName</span></a></span><span>   </span><span class="hs-comment">-- ^ Package name</span><span>
</span><span id="line-499"></span><span>                </span><span class="annot"><a href="GHC.Types.html#TrName"><span class="hs-identifier hs-type">TrName</span></a></span><span>   </span><span class="hs-comment">-- ^ Module name</span><span>
</span><span id="line-500"></span><span>
</span><span id="line-501"></span><span class="hs-keyword">data</span><span> </span><span id="TrName"><span class="annot"><a href="GHC.Types.html#TrName"><span class="hs-identifier hs-var">TrName</span></a></span></span><span>
</span><span id="line-502"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span id="TrNameS"><span class="annot"><a href="GHC.Types.html#TrNameS"><span class="hs-identifier hs-var">TrNameS</span></a></span></span><span> </span><span class="annot"><a href="GHC.Prim.html#Addr%23"><span class="hs-identifier hs-type">Addr#</span></a></span><span>  </span><span class="hs-comment">-- ^ Static</span><span>
</span><span id="line-503"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span id="TrNameD"><span class="annot"><a href="GHC.Types.html#TrNameD"><span class="hs-identifier hs-var">TrNameD</span></a></span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-comment">-- ^ Dynamic</span><span>
</span><span id="line-504"></span><span>
</span><span id="line-505"></span><span class="hs-comment">-- | A de Bruijn index for a binder within a 'KindRep'.</span><span>
</span><span id="line-506"></span><span class="hs-keyword">type</span><span> </span><span id="KindBndr"><span class="annot"><a href="GHC.Types.html#KindBndr"><span class="hs-identifier hs-var">KindBndr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-cpp">

#if WORD_SIZE_IN_BITS &lt; 64
</span><span class="hs-cpp">#define WORD64_TY Word64#
</span><span class="hs-cpp">#else
</span><span class="hs-cpp">#define WORD64_TY Word#
</span><span class="hs-cpp">#endif
</span><span>
</span><span id="line-514"></span><span class="hs-comment">-- | The representation produced by GHC for conjuring up the kind of a</span><span>
</span><span id="line-515"></span><span class="hs-comment">-- 'Data.Typeable.TypeRep'.</span><span>
</span><span id="line-516"></span><span>
</span><span id="line-517"></span><span class="hs-comment">-- See Note [Representing TyCon kinds: KindRep] in GHC.Tc.Instance.Typeable.</span><span>
</span><span id="line-518"></span><span class="hs-keyword">data</span><span> </span><span id="KindRep"><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-var">KindRep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="KindRepTyConApp"><span class="annot"><a href="GHC.Types.html#KindRepTyConApp"><span class="hs-identifier hs-var">KindRepTyConApp</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#TyCon"><span class="hs-identifier hs-type">TyCon</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-519"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepVar"><span class="annot"><a href="GHC.Types.html#KindRepVar"><span class="hs-identifier hs-var">KindRepVar</span></a></span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.Types.html#KindBndr"><span class="hs-identifier hs-type">KindBndr</span></a></span><span>
</span><span id="line-520"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepApp"><span class="annot"><a href="GHC.Types.html#KindRepApp"><span class="hs-identifier hs-var">KindRepApp</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span> </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span>
</span><span id="line-521"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepFun"><span class="annot"><a href="GHC.Types.html#KindRepFun"><span class="hs-identifier hs-var">KindRepFun</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span> </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span>
</span><span id="line-522"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepTYPE"><span class="annot"><a href="GHC.Types.html#KindRepTYPE"><span class="hs-identifier hs-var">KindRepTYPE</span></a></span></span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.Types.html#RuntimeRep"><span class="hs-identifier hs-type">RuntimeRep</span></a></span><span>
</span><span id="line-523"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepTypeLitS"><span class="annot"><a href="GHC.Types.html#KindRepTypeLitS"><span class="hs-identifier hs-var">KindRepTypeLitS</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#TypeLitSort"><span class="hs-identifier hs-type">TypeLitSort</span></a></span><span> </span><span class="annot"><a href="GHC.Prim.html#Addr%23"><span class="hs-identifier hs-type">Addr#</span></a></span><span>
</span><span id="line-524"></span><span>             </span><span class="hs-glyph">|</span><span> </span><span id="KindRepTypeLitD"><span class="annot"><a href="GHC.Types.html#KindRepTypeLitD"><span class="hs-identifier hs-var">KindRepTypeLitD</span></a></span></span><span> </span><span class="annot"><a href="GHC.Types.html#TypeLitSort"><span class="hs-identifier hs-type">TypeLitSort</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-525"></span><span>
</span><span id="line-526"></span><span class="hs-keyword">data</span><span> </span><span id="TypeLitSort"><span class="annot"><a href="GHC.Types.html#TypeLitSort"><span class="hs-identifier hs-var">TypeLitSort</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="TypeLitSymbol"><span class="annot"><a href="GHC.Types.html#TypeLitSymbol"><span class="hs-identifier hs-var">TypeLitSymbol</span></a></span></span><span>
</span><span id="line-527"></span><span>                 </span><span class="hs-glyph">|</span><span> </span><span id="TypeLitNat"><span class="annot"><a href="GHC.Types.html#TypeLitNat"><span class="hs-identifier hs-var">TypeLitNat</span></a></span></span><span>
</span><span id="line-528"></span><span>
</span><span id="line-529"></span><span class="hs-comment">-- Show instance for TyCon found in GHC.Show</span><span>
</span><span id="line-530"></span><span class="hs-keyword">data</span><span> </span><span id="TyCon"><span class="annot"><a href="GHC.Types.html#TyCon"><span class="hs-identifier hs-var">TyCon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="TyCon"><span class="annot"><a href="GHC.Types.html#TyCon"><span class="hs-identifier hs-var">TyCon</span></a></span></span><span> </span><span class="hs-identifier">WORD64_TY</span><span>  </span><span class="hs-comment">-- ^ Fingerprint (high)</span><span>
</span><span id="line-531"></span><span>                   </span><span class="hs-identifier">WORD64_TY</span><span>  </span><span class="hs-comment">-- ^ Fingerprint (low)</span><span>
</span><span id="line-532"></span><span>                   </span><span class="annot"><a href="GHC.Types.html#Module"><span class="hs-identifier hs-type">Module</span></a></span><span>     </span><span class="hs-comment">-- ^ Module in which this is defined</span><span>
</span><span id="line-533"></span><span>                   </span><span class="annot"><a href="GHC.Types.html#TrName"><span class="hs-identifier hs-type">TrName</span></a></span><span>     </span><span class="hs-comment">-- ^ Type constructor name</span><span>
</span><span id="line-534"></span><span>                   </span><span class="annot"><a href="GHC.Prim.html#Int%23"><span class="hs-identifier hs-type">Int#</span></a></span><span>       </span><span class="hs-comment">-- ^ How many kind variables do we accept?</span><span>
</span><span id="line-535"></span><span>                   </span><span class="annot"><a href="GHC.Types.html#KindRep"><span class="hs-identifier hs-type">KindRep</span></a></span><span>    </span><span class="hs-comment">-- ^ A representation of the type's kind</span><span>
</span><span id="line-536"></span></pre></body></html>